package com.google.code.mochaccino.framework.junit;
/*
 * Copyright 2012 Claude Houle claude.houle@gmail.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.Collection;
import java.util.Map;

/**
 * Simple Assertion Method that are easier/more pleasant to use than JUnit methods. Less verbose.
 *
 *
 */
public final class Assertion {
	private static final String VALIDATION_FAILED_MSG = "Validation failed! Activate Debug Logging Level to see messages";

	public static <T> void contains( Collection<T> array, T value ) {
		if ( !Validation.contains( array, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void contains( T[] array, T value ) {
		if ( !Validation.contains( array, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void contains( Collection<T> array, T value, String msg ) {
		if ( !Validation.contains( array, value ) ) {
			fail( msg );
		}
	}

	public static <T> void contains( T[] array, T value, String msg ) {
		if ( !Validation.contains( array, value ) ) {
			fail( msg );
		}
	}

	public static <T> void containsAll( Collection<T> expected, Collection<T> actual ) {
		if ( !Validation.containsAll( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void containsAll( T[] expected, T[] actual ) {
		if ( !Validation.containsAll( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void containsAll( Collection<T> expected, Collection<T> actual, String msg ) {
		if ( !Validation.containsAll( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void containsAll( T[] expected, T[] actual, String msg ) {
		if ( !Validation.containsAll( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <K,V> void containsEntry( Map<K,V> map, K key, V value ) {
		if ( !Validation.containsEntry( map, key, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void containsEntry( Map<K,V> map, K key, V value, String msg ) {
		if ( !Validation.containsEntry( map, key, value ) ) {
			fail( msg );
		}
	}

	public static <K,V> void containsKey( Map<K,V> map, K key ) {
		if ( !Validation.containsKey( map, key ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void containsKey( Map<K,V> map, K key, String msg ) {
		if ( !Validation.containsKey( map, key ) ) {
			fail( msg );
		}
	}

	public static <K,V> void containsValue( Map<K,V> map, V value ) {
		if ( !Validation.containsValue( map, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void containsValue( Map<K,V> map, V value, String msg ) {
		if ( !Validation.containsValue( map, value ) ) {
			fail( msg );
		}
	}

	public static <T> void different( T expected, T actual ) {
		if ( !Validation.different( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void different( T expected, T actual, String msg ) {
		if ( !Validation.different( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void empty( Collection<T> value ) {
		if ( !Validation.empty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T,V> void empty( Map<T,V> value ) {
		if ( !Validation.empty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void empty( T[] value ) {
		if ( !Validation.empty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void empty( Collection<T> value, String msg ) {
		if ( !Validation.empty( value ) ) {
			fail( msg );
		}
	}

	public static <T,V> void empty( Map<T,V> value, String msg ) {
		if ( !Validation.empty( value ) ) {
			fail( msg );
		}
	}

	public static <T> void empty( T[] value, String msg ) {
		if ( !Validation.empty( value ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( boolean[] expected, boolean[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( byte[] expected, byte[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( char[] expected, char[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( Collection<T> expected, Collection<T> actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( double[] expected, double[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( float[] expected, float[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( int[] expected, int[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( long[] expected, long[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void eq( Map<K,V> expected, Map<K,V> actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( short[] expected, short[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( T expected, T actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( T[] expected, T[] actual ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void eq( boolean[] expected, boolean[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( byte[] expected, byte[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( char[] expected, char[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( Collection<T> expected, Collection<T> actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( double[] expected, double[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( float[] expected, float[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( int[] expected, int[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( long[] expected, long[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <K,V> void eq( Map<K,V> expected, Map<K,V> actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( short[] expected, short[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( T expected, T actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void eq( T[] expected, T[] actual, String msg ) {
		if ( !Validation.eq( expected, actual ) ) {
			fail( msg );
		}
	}

	public static void fail( String message, Object... parameters ) {
		if ( parameters == null ) {
			parameters = new Object[] { };
		}
		throw new AssertionError( String.format( message, parameters ) );
	}

	public static void ge( int reference, int actual ) {
		if ( !Validation.ge( reference, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void ge( int reference, int actual, String msg ) {
		if ( !Validation.ge( reference, actual ) ) {
			fail( msg );
		}
	}

	public static void gt( int reference, int actual ) {
		if ( !Validation.ge( reference, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void gt( int reference, int actual, String msg ) {
		if ( !Validation.ge( reference, actual ) ) {
			fail( msg );
		}
	}

	public static void isFalse( boolean v ) {
		if ( !Validation.isFalse( v ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void isFalse( boolean v, String msg ) {
		if ( !Validation.isFalse( v ) ) {
			fail( msg );
		}
	}

	public static void isNotNull( Object o ) {
		if ( !Validation.isNotNull( o ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void isNotNull( Object o, String msg ) {
		if ( !Validation.isNotNull( o ) ) {
			fail( msg );
		}
	}

	public static void isNull( Object o ) {
		if ( !Validation.isNull( o ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void isNull( Object o, String msg ) {
		if ( !Validation.isNull( o ) ) {
			fail( msg );
		}
	}

	public static void isTrue( boolean v ) {
		if ( !Validation.isTrue( v ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void isTrue( boolean v, String msg ) {
		if ( !Validation.isTrue( v ) ) {
			fail( msg );
		}
	}

	public static void le( int reference, int actual ) {
		if ( !Validation.le( reference, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void le( int reference, int actual, String msg ) {
		if ( !Validation.le( reference, actual ) ) {
			fail( msg );
		}
	}

	public static void lt( int reference, int actual ) {
		if ( !Validation.le( reference, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static void lt( int reference, int actual, String msg ) {
		if ( !Validation.le( reference, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( boolean[] expected, boolean[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( byte[] expected, byte[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( char[] expected, char[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( Collection<T> expected, Collection<T> actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( double[] expected, double[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( float[] expected, float[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( int[] expected, int[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( long[] expected, long[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void ne( Map<K,V> expected, Map<K,V> actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( short[] expected, short[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( T expected, T actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( T[] expected, T[] actual ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void ne( boolean[] expected, boolean[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( byte[] expected, byte[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( char[] expected, char[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( Collection<T> expected, Collection<T> actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( double[] expected, double[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( float[] expected, float[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( int[] expected, int[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( long[] expected, long[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <K,V> void ne( Map<K,V> expected, Map<K,V> actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( short[] expected, short[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( T expected, T actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void ne( T[] expected, T[] actual, String msg ) {
		if ( !Validation.ne( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void notContains( Collection<T> array, T value ) {
		if ( !Validation.notContains( array, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notContains( T[] array, T value ) {
		if ( !Validation.notContains( array, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notContains( Collection<T> array, T value, String msg ) {
		if ( !Validation.notContains( array, value ) ) {
			fail( msg );
		}
	}

	public static <T> void notContains( T[] array, T value, String msg ) {
		if ( !Validation.notContains( array, value ) ) {
			fail( msg );
		}
	}

	public static <T> void notContainsAll( Collection<T> expected, Collection<T> actual ) {
		if ( !Validation.notContainsAll( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notContainsAll( T[] expected, T[] actual ) {
		if ( !Validation.notContainsAll( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notContainsAll( Collection<T> expected, Collection<T> actual, String msg ) {
		if ( !Validation.notContainsAll( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void notContainsAll( T[] expected, T[] actual, String msg ) {
		if ( !Validation.notContainsAll( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <K,V> void notContainsEntry( Map<K,V> map, K key, V value ) {
		if ( !Validation.notContainsEntry( map, key, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void notContainsEntry( Map<K,V> map, K key, V value, String msg ) {
		if ( !Validation.notContainsEntry( map, key, value ) ) {
			fail( msg );
		}
	}

	public static <K,V> void notContainsKey( Map<K,V> map, K key ) {
		if ( !Validation.notContainsKey( map, key ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void notContainsKey( Map<K,V> map, K key, String msg ) {
		if ( !Validation.notContainsKey( map, key ) ) {
			fail( msg );
		}
	}

	public static <K,V> void notContainsValue( Map<K,V> map, V value ) {
		if ( !Validation.notContainsValue( map, value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void notContainsValue( Map<K,V> map, V value, String msg ) {
		if ( !Validation.notContainsValue( map, value ) ) {
			fail( msg );
		}
	}

	public static <T> void notEmpty( Collection<T> value ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T,V> void notEmpty( Map<T,V> value ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notEmpty( T[] value ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void notEmpty( Collection<T> value, String msg ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( msg );
		}
	}

	public static <T,V> void notEmpty( Map<T,V> value, String msg ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( msg );
		}
	}

	public static <T> void notEmpty( T[] value, String msg ) {
		if ( !Validation.notEmpty( value ) ) {
			fail( msg );
		}
	}

	public static <T> void same( T expected, T actual ) {
		if ( !Validation.same( expected, actual ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void same( T expected, T actual, String msg ) {
		if ( !Validation.same( expected, actual ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeEq( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void sizeEq( Map<K,V> array, int expectedSize ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeEq( T[] array, int expectedSize ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeEq( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <K,V> void sizeEq( Map<K,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeEq( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeEq( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeGe( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void sizeGe( Map<K,V> array, int expectedSize ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeGe( T[] array, int expectedSize ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeGe( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <K,V> void sizeGe( Map<K,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeGe( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeGe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeGt( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <K,V> void sizeGt( Map<K,V> array, int expectedSize ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeGt( T[] array, int expectedSize ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeGt( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <K,V> void sizeGt( Map<K,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeGt( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeGt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeLe( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T,V> void sizeLe( Map<T,V> array, int expectedSize ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeLe( T[] array, int expectedSize ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeLe( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T,V> void sizeLe( Map<T,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeLe( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeLe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeLt( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T,V> void sizeLt( Map<T,V> array, int expectedSize ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeLt( T[] array, int expectedSize ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeLt( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T,V> void sizeLt( Map<T,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeLt( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeLt( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeNe( Collection<T> array, int expectedSize ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T,V> void sizeNe( Map<T,V> array, int expectedSize ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeNe( T[] array, int expectedSize ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( VALIDATION_FAILED_MSG );
		}
	}

	public static <T> void sizeNe( Collection<T> array, int expectedSize, String msg ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T,V> void sizeNe( Map<T,V> array, int expectedSize, String msg ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( msg );
		}
	}

	public static <T> void sizeNe( T[] array, int expectedSize, String msg ) {
		if ( !Validation.sizeNe( array, expectedSize ) ) {
			fail( msg );
		}
	}
}
